home *** CD-ROM | disk | FTP | other *** search
/ Network CD 2 / Network CD - Volume 2.iso / programs / internet / envoy / netprobe_4_24.lha / NetProbe / src / ui-MUI.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-11  |  34.7 KB  |  1,149 lines
  1. //
  2. //  $Log: ui-MUI.c,v $
  3. //  Revision 1.11  1994/09/10  23:01:47  hakan
  4. //  Changed all button-notifies to FALSE.  They operate on releasing the
  5. //  button now.
  6. //
  7. //  Revision 1.10  1994/09/10  14:32:32  hakan
  8. //  ScanPing wurx
  9. //
  10. //  Revision 1.9  1994/08/15  22:46:42  hakan
  11. //  Minor glitch.  Forgot a break.
  12. //
  13. //  Revision 1.8  1994/08/15  22:32:50  hakan
  14. //  Should be finished.
  15. //
  16. //  Revision 1.7  1994/08/10  09:39:59  hakan
  17. //  All scanning functions ready
  18. //
  19. //  Revision 1.6  1994/07/12  22:10:43  hakan
  20. //  DecodeHost with accessory functions programmed
  21. //
  22. //  Revision 1.5  1994/07/12  21:01:30  hakan
  23. //  Just another paranoia ci
  24. //
  25. //  Revision 1.4  1994/06/19  23:37:35  hakan
  26. //  Intermediate ci.  Just getting paranoid :)
  27. //  Lot's of UI and a HostRequest are functional
  28. //
  29. //  Revision 1.3  1994/06/19  15:34:06  hakan
  30. //  Lotz'a stuff
  31. //
  32. //  Revision 1.2  1994/06/15  01:55:36  hakan
  33. //  GUI faithfully copied from version 3.x
  34. //
  35. //  Revision 1.1  1994/06/14  20:30:25  hakan
  36. //  Initial revision
  37. //
  38. //
  39.  
  40. static char* RCSId = "$Id: ui-MUI.c,v 1.11 1994/09/10 23:01:47 hakan Exp $";
  41.  
  42. #include "extern.h"
  43. #include "ui-MUI.h"
  44.  
  45.  
  46.  
  47. static void HandleCheckBox (APTR CheckBox, APTR StringGadget);
  48. static void BuildConfiguration (void);
  49. static void DecodeHost (Host* foo);
  50. static void Add (APTR list, char* string);
  51.  
  52.  
  53.  
  54. struct Library*         MUIMasterBase;
  55. struct DiskObject*      icon;
  56. char                    pathbuf [256];
  57. char                    hostbuf [32 + 32 + 1];
  58. static struct NewMenu   mnNetProbe[] =
  59. {
  60.     { NM_TITLE, "Project",          0,  0,  0,  0,},
  61.     {  NM_ITEM, "About",           "?", 0,  0,  (void*) ID_About,},
  62.     {  NM_ITEM, NM_BARLABEL,        0,  0,  0,  0,},
  63.     {  NM_ITEM, "Save List",       "W", 0,  0,  (void*) ID_Save_List,},
  64.     {  NM_ITEM, "Preferences...",  "P", 0,  0,  (void*) ID_Prefs,},
  65.     {  NM_ITEM, NM_BARLABEL,        0,  0,  0,  0,},
  66.     {  NM_ITEM, "Quit",            "Q", 0,  0,  (void*) ID_Quit,},
  67.  
  68.     {   NM_END, 0,                  0,  0,  0,  0,},
  69. };
  70.  
  71. APTR    MUIApp;
  72.  
  73. APTR    MUIwinMain,
  74.         MUIbtScanRealms,
  75.         MUIbtScanHosts,
  76.         MUIbtScanAllHosts,
  77.         MUIbtQuit,
  78.         MUIbtScanPing,
  79.         MUIbtScanPingHost,
  80.         MUIcbOwner,         MUIstOwner,
  81.         MUIcbIPAddr,        MUIstIPAddr,
  82.         MUIcbKickStart,     MUIstKickStart,
  83.         MUIcbWorkBench,     MUIstWorkBench,
  84.         MUIcbNIPC,          MUIstNIPC,
  85.         MUIcbFastMem,       MUIstFastMem,
  86.         MUIcbChipMem,       MUIstChipMem,
  87.         MUIcbProcessor,     MUIstProcessor,
  88.         MUIcbChips,         MUIstChips,
  89.                             MUIlvRealms,
  90.                             MUIlvHosts,
  91.         MUIcbServices,      MUIlvServices,
  92.         MUIcbEntities,      MUIlvEntities;
  93.  
  94. APTR    MUIwinPrefs,
  95.         MUIstScanTime,
  96.         MUIstScanPackets,
  97.         MUIstSaveFileName,
  98.         MUIstPingHost,
  99.         MUIbt402Kludge,
  100.         MUIbtPingHost,
  101.         MUIbtPrefsPath,
  102.         MUIbtPrefsSave,
  103.         MUIbtPrefsUse,
  104.         MUIbtPrefsCancel;
  105.  
  106. APTR    MUIwinScan,
  107.         MUIfgScanTime,
  108.         MUIbtStopScan;
  109.  
  110.  
  111.  
  112. BOOL CreateUI (int argc, char* argv[])
  113. {
  114.     long exportid = 1;
  115.  
  116.  
  117.     if (!(MUIMasterBase = OpenLibrary ("muimaster.library", 3)))
  118.     {
  119.         return (FALSE);
  120.     }
  121.  
  122.  
  123.     //
  124.     //  First,  we need an application
  125.     //
  126.  
  127.     MUIApp = ApplicationObject,
  128.         MUIA_Application_Title,         "NetProbe",
  129.         MUIA_Application_Version,       getVersTag (),
  130.         MUIA_Application_Copyright,     "©1993,1994, Hakan Tandogan",
  131.         MUIA_Application_Author,        "Hakan Tandogan",
  132.         MUIA_Application_Description,   "Scans an Envoy Network",
  133.         MUIA_Application_Base,          "NETPROBE",
  134.         MUIA_Application_Menu,          mnNetProbe,
  135.         MUIA_Application_DiskObject,    icon = GetDiskObject ("NetProbe"),
  136.         MUIA_HelpFile,                  "NetProbe.guide",
  137.  
  138.         End;
  139.  
  140.     if (!(MUIApp))
  141.     {
  142.         return (FALSE);
  143.     }
  144.  
  145.  
  146.     //
  147.     //  Primary preferences items
  148.     //
  149.  
  150.     MUIstScanTime = StringObject, StringFrame,
  151.         MUIA_String_MaxLen,     5,
  152.         MUIA_String_Format,     MUIV_String_Format_Left,
  153.         MUIA_String_Accept,     "0123456789",
  154.         MUIA_ExportID,          exportid++,
  155.         End;
  156.  
  157.     MUIstScanPackets = StringObject, StringFrame,
  158.         MUIA_String_MaxLen,     5,
  159.         MUIA_String_Format,     MUIV_String_Format_Left,
  160.         MUIA_String_Accept,     "0123456789",
  161.         MUIA_ExportID,          exportid++,
  162.         End;
  163.  
  164.     MUIstSaveFileName = StringObject, StringFrame,
  165.         MUIA_String_Format,     MUIV_String_Format_Left,
  166.         MUIA_ExportID,          exportid++,
  167.         End;
  168.  
  169.     MUIstPingHost = StringObject, StringFrame,
  170.         MUIA_String_Format,     MUIV_String_Format_Left,
  171.         MUIA_ExportID,          exportid++,
  172.         End;
  173.  
  174.     MUIbt402Kludge  = KeyCheckmark (TRUE, 'k', exportid++);
  175.     MUIbtPingHost   = KeyCheckmark (TRUE, 's', exportid++);
  176.  
  177.     if (!(MUIstScanTime  && MUIstScanPackets && MUIstSaveFileName
  178.        && MUIbt402Kludge && MUIbtPingHost    && MUIstPingHost))
  179.     {
  180.         return (FALSE);
  181.     }
  182.  
  183.  
  184.     //
  185.     //  Now we create our main window
  186.     //
  187.  
  188.     MUIwinMain = WindowObject,
  189.         MUIA_Window_Title,  getWindowVersionString(), //  "NetProbe 4.3",
  190.         MUIA_Window_ID,     MAKE_ID ('M','A','I','N'),
  191.  
  192.         WindowContents, VGroup,
  193.             //
  194.             //  Top three gadgets
  195.             //
  196.             Child, HGroup,
  197.                 MUIA_Group_SameSize, TRUE,
  198.                 Child, MUIbtScanRealms      = KeyButton ("Scan Realms", 'r'),
  199.                 Child, MUIbtScanHosts       = KeyButton ("Scan Hosts", 'h'),
  200.                 Child, MUIbtScanAllHosts    = KeyButton ("Scan All", 'a'),
  201.                 Child, MUIbtQuit            = KeyButton ("Quit", 'q'),
  202.                 End,
  203.  
  204.             //
  205.             //  Ping-Host stuff
  206.             //
  207.             Child, HGroup,
  208.                 MUIA_Group_SameSize, TRUE,
  209.                 Child, MUIbtScanPing = KeyButton ("Ping Host", 'g'),
  210.                 Child, HGroup,
  211.                     MUIA_Group_SameSize, FALSE,
  212.                     Child, MUIstPingHost,
  213.                     Child, MUIbtScanPingHost = PopupGadget,
  214.                     End,
  215.                 End,
  216.  
  217.             //
  218.             //  Here comes Information
  219.             //
  220.             Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, End,
  221.  
  222.             Child, ColGroup (2),
  223.                 Child, HGroup,
  224.                     Child, VGroup,
  225.                         Child, MUIlvRealms = ListviewObject,
  226.                             MUIA_Weight, 50,
  227.                             MUIA_Listview_List, ListObject,
  228.                                 InputListFrame,
  229.                                 End,
  230.                             End,
  231.  
  232.                         Child, MUIlvHosts = ListviewObject,
  233.                             MUIA_Weight, 200,
  234.                             MUIA_Listview_List, ListObject,
  235.                                 InputListFrame,
  236.                                 End,
  237.                             End,
  238.  
  239.                         End,
  240.                     End,
  241.  
  242.                     Child, VGroup,
  243.                         ListViewWithKey (MUIcbServices, MUIlvServices,  exportid++, 's',    "Services"),
  244.                         ListViewWithKey (MUIcbEntities, MUIlvEntities,  exportid++, 'e',    "Entities"),
  245.                         End,
  246.                     End,
  247.  
  248.                 Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, End,
  249.  
  250.                 Child, ColGroup (3),
  251.                     GadgetLine (MUIcbOwner,     MUIstOwner,     exportid++, 'o', "Owner:"),
  252.                     GadgetLine (MUIcbIPAddr,    MUIstIPAddr,    exportid++, 'i', "IP-Addr"),
  253.                     GadgetLine (MUIcbKickStart, MUIstKickStart, exportid++, 'k', "Kickstart:"),
  254.                     GadgetLine (MUIcbWorkBench, MUIstWorkBench, exportid++, 'w', "Workbench:"),
  255.                     GadgetLine (MUIcbNIPC,      MUIstNIPC,      exportid++, 'n', "NIPC:"),
  256.                     GadgetLine (MUIcbFastMem,   MUIstFastMem,   exportid++, 'f', "Fast Memory:"),
  257.                     GadgetLine (MUIcbChipMem,   MUIstChipMem,   exportid++, 'y', "Chip Memory:"),
  258.                     GadgetLine (MUIcbProcessor, MUIstProcessor, exportid++, 'p', "Processor:"),
  259.                     GadgetLine (MUIcbChips,     MUIstChips,     exportid++, 'c', "Custom Chips:"),
  260.                 End,
  261.             End,
  262.         End;
  263.  
  264.     if (!(MUIwinMain))
  265.     {
  266.         return (FALSE);
  267.     }
  268.  
  269.     DoMethod (MUIwinMain,        MUIM_Notify, MUIA_Window_CloseRequest, TRUE,           MUIApp, 2, MUIM_Application_ReturnID, ID_Quit);
  270.     DoMethod (MUIbtScanRealms,   MUIM_Notify, MUIA_Pressed,             FALSE,          MUIApp, 2, MUIM_Application_ReturnID, ID_Scan_Realms);
  271.     DoMethod (MUIbtScanHosts,    MUIM_Notify, MUIA_Pressed,             FALSE,          MUIApp, 2, MUIM_Application_ReturnID, ID_Scan_Hosts);
  272.     DoMethod (MUIbtScanAllHosts, MUIM_Notify, MUIA_Pressed,             FALSE,          MUIApp, 2, MUIM_Application_ReturnID, ID_Scan_All);
  273.     DoMethod (MUIbtScanPing,     MUIM_Notify, MUIA_Pressed,             FALSE,          MUIApp, 2, MUIM_Application_ReturnID, ID_Scan_Ping);
  274.     DoMethod (MUIbtQuit,         MUIM_Notify, MUIA_Pressed,             FALSE,          MUIApp, 2, MUIM_Application_ReturnID, ID_Quit);
  275.  
  276.     DoMethod (MUIbtScanPingHost, MUIM_Notify, MUIA_Pressed,             FALSE,          MUIApp, 2, MUIM_Application_ReturnID, ID_HostRequest);
  277.  
  278.     DoMethod (MUIlvHosts,        MUIM_Notify, MUIA_List_Active,         MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_LV_Hosts_Changed);
  279.     DoMethod (MUIlvRealms,       MUIM_Notify, MUIA_List_Active,         MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_LV_Realms_Changed);
  280.     DoMethod (MUIlvRealms,       MUIM_Notify, MUIA_Listview_DoubleClick, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_Scan_Hosts);
  281.  
  282.     DoMethod (MUIcbEntities,     MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_Entities);
  283.     DoMethod (MUIcbServices,     MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_Services);
  284.     DoMethod (MUIcbOwner,        MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_Owner);
  285.     DoMethod (MUIcbIPAddr,       MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_IPAddr);
  286.     DoMethod (MUIcbKickStart,    MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_KickStart);
  287.     DoMethod (MUIcbWorkBench,    MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_WorkBench);
  288.     DoMethod (MUIcbNIPC,         MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_NIPC);
  289.     DoMethod (MUIcbFastMem,      MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_FastMem);
  290.     DoMethod (MUIcbChipMem,      MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_ChipMem);
  291.     DoMethod (MUIcbProcessor,    MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_Processor);
  292.     DoMethod (MUIcbChips,        MUIM_Notify, MUIA_Selected,            MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ID_BT_Chips);
  293.  
  294.     DoMethod (MUIwinMain, MUIM_Window_SetCycleChain,
  295.         MUIbtScanRealms,
  296.         MUIbtScanHosts,
  297.         MUIbtScanAllHosts,
  298.         MUIbtQuit,
  299.         MUIbtScanPing,
  300.         MUIstPingHost,
  301.         MUIlvRealms,
  302.         MUIlvHosts,
  303.         NULL );
  304.  
  305.     DoMethod (MUIwinMain, MUIA_Window_ActiveObject, MUIbtScanHosts);
  306.  
  307.     DoMethod (MUIApp, OM_ADDMEMBER, MUIwinMain);
  308.  
  309.  
  310.     //
  311.     //  Here goes the preferences window
  312.     //
  313.  
  314.     MUIwinPrefs = WindowObject,
  315.         MUIA_Window_Title,  "NetProbe Preferences",
  316.         MUIA_Window_ID,     MAKE_ID ('P','R','F','S'),
  317.  
  318.         WindowContents, VGroup,
  319.             Child, ColGroup (2),
  320.                 Child, Label2 ("Max. Scan Time: "), Child, MUIstScanTime,
  321.                 Child, Label2 ("Max. Packets: "),   Child, MUIstScanPackets,
  322.                 Child, Label2 ("Save file Path: "), Child, HGroup,
  323.                                                         Child, MUIstSaveFileName,
  324.                                                         Child, MUIbtPrefsPath = PopupGadget,
  325.                                                         End,
  326.  
  327.                 Child, Label1 ("40.2-Kludge: "),    Child, HGroup,
  328.                                                         Child, MUIbt402Kludge,
  329.                                                         Child, HSpace (0),
  330.                                                         End,
  331.                 Child, Label1 ("Ping Hosts: "),     Child, HGroup,
  332.                                                         Child, MUIbtPingHost,
  333.                                                         Child, HSpace (0),
  334.                                                         End,
  335.                 End,
  336.  
  337.             Child, VSpace (0),
  338.  
  339.             Child, HGroup,
  340.                 MUIA_Group_SameSize, TRUE,
  341.  
  342.                 Child, MUIbtPrefsSave   = KeyButton ("Save", 's'),
  343.                 Child, MUIbtPrefsUse    = KeyButton ("Use", 'u'),
  344.                 Child, MUIbtPrefsCancel = KeyButton ("Cancel", 'c'),
  345.                 End,
  346.  
  347.             End,
  348.  
  349.         End;
  350.  
  351.     if (!(MUIwinPrefs))
  352.     {
  353.         return (FALSE);
  354.     }
  355.  
  356.     DoMethod (MUIwinPrefs,      MUIM_Notify, MUIA_Window_CloseRequest, TRUE,            MUIApp, 2, MUIM_Application_ReturnID, ID_Prefs_Quit);
  357.     DoMethod (MUIbtPrefsPath,   MUIM_Notify, MUIA_Pressed,             FALSE,           MUIApp, 2, MUIM_Application_ReturnID, ID_Prefs_Path);
  358.     DoMethod (MUIbtPrefsSave,   MUIM_Notify, MUIA_Pressed,             FALSE,           MUIApp, 2, MUIM_Application_ReturnID, ID_Prefs_Save);
  359.     DoMethod (MUIbtPrefsUse,    MUIM_Notify, MUIA_Pressed,             FALSE,           MUIApp, 2, MUIM_Application_ReturnID, ID_Prefs_Use);
  360.     DoMethod (MUIbtPrefsCancel, MUIM_Notify, MUIA_Pressed,             FALSE,           MUIApp, 2, MUIM_Application_ReturnID, ID_Prefs_Cancel);
  361.     DoMethod (MUIbtPingHost,    MUIM_Notify, MUIA_Selected,            MUIV_EveryTime,  MUIApp, 2, MUIM_Application_ReturnID, ID_BT_PingHost);
  362.  
  363.     DoMethod (MUIwinPrefs, MUIM_Window_SetCycleChain,
  364.         MUIstScanTime,
  365.         MUIstScanPackets,
  366.         MUIstSaveFileName,
  367.         MUIbtPrefsPath,
  368.         MUIbtPrefsSave,
  369.         MUIbtPrefsUse,
  370.         MUIbtPrefsCancel,
  371.         NULL );
  372.  
  373.     DoMethod (MUIwinPrefs, MUIA_Window_ActiveObject, MUIbtPrefsUse);
  374.  
  375.     DoMethod (MUIApp, OM_ADDMEMBER, MUIwinPrefs);
  376.  
  377.  
  378.     //
  379.     //  This is the scanning window
  380.     //
  381.  
  382.     MUIwinScan = WindowObject,
  383.         MUIA_Window_Title,  "NetProbe Scanning",
  384.         MUIA_Window_ID,     MAKE_ID ('S','C','A','N'),
  385.         MUIA_Window_Menu,   MUIV_Window_Menu_NoMenu,
  386.  
  387.         WindowContents, VGroup,
  388.             Child,
  389.                 ColGroup (3),
  390.                     Child, HSpace (0),
  391.                     Child, Label1 ("Scanning"),
  392.                     Child, HSpace (0),
  393.                 End,
  394.  
  395.                 Child, MUIfgScanTime = GaugeObject, GaugeFrame, MUIA_Gauge_Horiz, TRUE, End,
  396.  
  397.                 Child, VSpace (0),
  398.                 
  399.                 Child, MUIbtStopScan = KeyButton ("Stop", 's'),
  400.             End,
  401.         End;
  402.  
  403.     if (!(MUIwinScan))
  404.     {
  405.         return (FALSE);
  406.     }
  407.  
  408.     DoMethod (MUIbtStopScan, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ID_Stop_Scan);
  409.  
  410.     DoMethod (MUIwinScan, MUIM_Window_SetCycleChain,
  411.         MUIbtStopScan,
  412.         NULL );
  413.  
  414.     DoMethod (MUIwinScan, MUIA_Window_ActiveObject, MUIbtStopScan);
  415.  
  416.     DoMethod (MUIApp, OM_ADDMEMBER, MUIwinScan);
  417.  
  418.  
  419.     //
  420.     //  The application is set up,  so load our preferences
  421.     //
  422.  
  423.     {
  424.         char* foo;
  425.  
  426.  
  427.         DoMethod (MUIApp, MUIM_Application_Load, "ENV:"PATH_PREFS);
  428.  
  429.         get (MUIstScanTime, MUIA_String_Contents, &foo);
  430.         if ((*foo == 0) || (atol (foo) == 0))
  431.         {
  432.             set (MUIstScanTime, MUIA_String_Contents, "1");
  433.         }
  434.  
  435.         get (MUIstScanPackets, MUIA_String_Contents, &foo);
  436.         if ((*foo == 0) || (atol (foo) == 0))
  437.         {
  438.             set (MUIstScanPackets, MUIA_String_Contents, "10");
  439.         }
  440.  
  441.         get (MUIstSaveFileName, MUIA_String_Contents, &foo);
  442.         if (*foo == 0)
  443.         {
  444.             set (MUIstSaveFileName, MUIA_String_Contents, "NetProbe.list");
  445.         }
  446.  
  447.         get (MUIstPingHost, MUIA_String_Contents, &foo);
  448.         if (*foo == 0)
  449.         {
  450.             set (MUIstPingHost, MUIA_String_Contents, "kahalo:kahalo");
  451.         }
  452.     }
  453.  
  454.  
  455.     //
  456.     //  Hey,  we did it!
  457.     //
  458.  
  459.     return (TRUE);
  460. }
  461.  
  462.  
  463.  
  464. void DestroyUI (void)
  465. {
  466.     if (icon)
  467.     {
  468.         FreeDiskObject (icon);
  469.         icon = NULL;
  470.     }
  471.  
  472.     if (MUIApp)
  473.     {
  474.         MUI_DisposeObject (MUIApp);
  475.         MUIApp = NULL;
  476.     }
  477.  
  478.     if (MUIMasterBase)
  479.     {
  480.         CloseLibrary (MUIMasterBase);
  481.         MUIMasterBase = NULL;
  482.     }
  483. }
  484.  
  485.  
  486.  
  487. void EventLoop (void)
  488. {
  489.     ULONG   signals = 0;
  490.     BOOL    running = TRUE;
  491.  
  492.  
  493.     if (!(RealmServerRunning ()))
  494.     {
  495.         set (MUIbtScanRealms,   MUIA_Disabled, TRUE);
  496.         set (MUIbtScanAllHosts, MUIA_Disabled, TRUE);
  497.         set (MUIlvRealms,       MUIA_Disabled, TRUE);
  498.     }
  499.  
  500.     set (MUIwinMain,  MUIA_Window_Open, TRUE);
  501.  
  502.     while (running)
  503.     {
  504.         switch (DoMethod (MUIApp, MUIM_Application_Input, &signals))
  505.         {
  506.             case MUIV_Application_ReturnID_Quit:
  507.             case ID_Quit:
  508.                 running = FALSE;
  509.                 break;
  510.  
  511.             case ID_About:
  512.                 MUI_Request (MUIApp, MUIwinMain, 0, NULL, "*Excellent",
  513.                     "\33c%s\n"
  514.                     "\33c\n"
  515.                     "\33c© 1993,1994 Hakan Tandogan\n"
  516.                     "\33cFreely  distributable\n"
  517.                     "\33c\n"
  518.                     "\33cPlease note the cardware status of\n"
  519.                     "\33cthis program.\n"
  520.                     "\33c\n"
  521.                     "\33cThis is a MUI-Application.\n"
  522.                     "\33cMUI is copyrighted by Stefan Stuntz.",
  523.                     getAboutVersionString ());
  524.                 break;
  525.  
  526.             case ID_Save_List:
  527.                 {
  528.                     char* SaveFileName;
  529.  
  530.                     get (MUIstSaveFileName, MUIA_String_Contents, &SaveFileName);
  531.                     SaveList (SaveFileName);
  532.                 }
  533.                 break;
  534.  
  535.                 
  536.             case ID_HostRequest:    
  537.                 {
  538.                     LONG topedge;
  539.                     LONG height;
  540.                     LONG leftedge;
  541.                     LONG width;
  542.  
  543.                     get (MUIwinMain, MUIA_Window_TopEdge,   &topedge);
  544.                     get (MUIwinMain, MUIA_Window_Height,    &height);
  545.                     get (MUIwinMain, MUIA_Window_LeftEdge,  &leftedge);
  546.                     get (MUIwinMain, MUIA_Window_Width,     &width);
  547.  
  548.                     if (HostRequest (HREQ_Title,    "NetProbe Host Request",
  549.                                      HREQ_Top,      topedge + height / 4,
  550.                                      HREQ_Height,   height / 2,
  551.                                      HREQ_Left,     leftedge,
  552.                                      HREQ_Width,    width,
  553.                                      HREQ_Buffer,   &hostbuf,
  554.                                      HREQ_BuffSize, sizeof (hostbuf) - 1,
  555.                                      (!(RealmServerRunning)) ? HREQ_NoRealms : TAG_DONE,    0,
  556.                                      TAG_DONE))
  557.  
  558.                     {
  559.                         set (MUIstPingHost, MUIA_String_Contents, &hostbuf);
  560.                     }
  561.                 }
  562.                 break;
  563.  
  564.             case ID_Prefs:
  565.                 set (MUIwinPrefs, MUIA_Window_Open, TRUE);
  566.                 break;
  567.  
  568.             case ID_Prefs_Quit:
  569.                 set (MUIwinPrefs, MUIA_Window_Open, FALSE);
  570.                 break;
  571.  
  572.             case ID_Prefs_Path:
  573.                 {
  574.                     LONG                    leftedge;
  575.                     LONG                    topedge;
  576.                     struct FileRequester*   FileRequester;
  577.                     struct Window*          parent;
  578.  
  579.  
  580.                     get (MUIwinPrefs, MUIA_Window_Window,   &parent);
  581.                     get (MUIwinPrefs, MUIA_Window_LeftEdge, &leftedge);
  582.                     get (MUIwinPrefs, MUIA_Window_TopEdge,  &topedge);
  583.  
  584.                     if (FileRequester = MUI_AllocAslRequestTags (ASL_FileRequest,
  585.                                                                  ASLFR_Window,          parent,
  586.                                                                  ASLFR_InitialLeftEdge, leftedge,
  587.                                                                  ASLFR_InitialTopEdge,  topedge,
  588.                                                                  ASLFR_TitleText,       "Select Save File",
  589.                                                                  TAG_DONE))
  590.                     {
  591.                         set (MUIwinPrefs, MUIA_Window_Sleep, TRUE);
  592.  
  593.                         if (MUI_AslRequestTags ((APTR) FileRequester, TAG_DONE))
  594.                         {
  595.                             stccpy (pathbuf, FileRequester->fr_Drawer, sizeof (pathbuf));
  596.  
  597.                             AddPart (pathbuf, FileRequester->fr_File, sizeof (pathbuf));
  598.  
  599.                             set (MUIstSaveFileName, MUIA_String_Contents, pathbuf);
  600.                         }
  601.  
  602.                         set (MUIwinPrefs, MUIA_Window_Sleep, FALSE);
  603.  
  604.                         MUI_FreeAslRequest (FileRequester);
  605.                     }
  606.                 }
  607.                 break;
  608.  
  609.             case ID_Prefs_Save:
  610.                 DoMethod (MUIApp, MUIM_Application_Save, "ENVARC:" PATH_PREFS);
  611.                 DoMethod (MUIApp, MUIM_Application_Save, "ENV:"    PATH_PREFS);
  612.                 set (MUIwinPrefs, MUIA_Window_Open, FALSE);
  613.                 break;
  614.  
  615.             case ID_Prefs_Use:
  616.                 DoMethod (MUIApp, MUIM_Application_Save, "ENV:"    PATH_PREFS);
  617.                 set (MUIwinPrefs, MUIA_Window_Open, FALSE);
  618.                 break;
  619.  
  620.             case ID_Prefs_Cancel:
  621.                 set (MUIwinPrefs, MUIA_Window_Open, FALSE);
  622.                 break;
  623.  
  624.             case ID_BT_PingHost:
  625.                 {
  626.                     long selected;
  627.  
  628.                     get (MUIbtPingHost, MUIA_Selected, &selected);
  629.                     if (selected)
  630.                     {
  631.                         set (MUIbtScanPing, MUIA_Disabled, FALSE);
  632.                         set (MUIstPingHost, MUIA_Disabled, FALSE);
  633.                     }
  634.                     else
  635.                     {
  636.                         set (MUIbtScanPing, MUIA_Disabled, TRUE);
  637.                         set (MUIstPingHost, MUIA_Disabled, TRUE);
  638.                     }
  639.                 }
  640.                 break;
  641.  
  642.             case ID_BT_Entities:
  643.                 HandleCheckBox (MUIcbEntities,  MUIlvEntities);
  644.                 break;
  645.  
  646.             case ID_BT_Services:
  647.                 HandleCheckBox (MUIcbServices,  MUIlvServices);
  648.                 break;
  649.  
  650.             case ID_BT_Owner:
  651.                 HandleCheckBox (MUIcbOwner,     MUIstOwner);
  652.                 break;
  653.  
  654.             case ID_BT_IPAddr:
  655.                 HandleCheckBox (MUIcbIPAddr,    MUIstIPAddr);
  656.                 break;
  657.  
  658.             case ID_BT_KickStart:
  659.                 HandleCheckBox (MUIcbKickStart, MUIstKickStart);
  660.                 break;
  661.  
  662.             case ID_BT_WorkBench:
  663.                 HandleCheckBox (MUIcbWorkBench, MUIstWorkBench);
  664.                 break;
  665.  
  666.             case ID_BT_NIPC:
  667.                 HandleCheckBox (MUIcbNIPC,      MUIstNIPC);
  668.                 break;
  669.  
  670.             case ID_BT_FastMem:
  671.                 HandleCheckBox (MUIcbFastMem,   MUIstFastMem);
  672.                 break;
  673.  
  674.             case ID_BT_ChipMem:
  675.                 HandleCheckBox (MUIcbChipMem,   MUIstChipMem);
  676.                 break;
  677.  
  678.             case ID_BT_Processor:
  679.                 HandleCheckBox (MUIcbProcessor, MUIstProcessor);
  680.                 break;
  681.  
  682.             case ID_BT_Chips:
  683.                 HandleCheckBox (MUIcbChips,     MUIstChips);
  684.                 break;
  685.                 
  686.             case ID_Scan_Realms:
  687.                 {
  688.                     struct Node*    realm;
  689.  
  690.                     DoMethod (MUIlvRealms, MUIM_List_Clear);
  691.                     BuildConfiguration ();
  692.                     ScanRealms ();
  693.  
  694.                     for (realm = Realms()->lh_Head; realm->ln_Succ; realm = realm->ln_Succ)
  695.                     {
  696.                         DoMethod (MUIlvRealms, MUIM_List_Insert, &(realm->ln_Name), 1, MUIV_List_Insert_Sorted);
  697.                     }
  698.                 }
  699.                 break;
  700.  
  701.             case ID_Scan_Hosts:
  702.                 {
  703.                     struct Node*    host;
  704.                     struct List*    hosts;
  705.                     unsigned long   selected;
  706.                     APTR            realmname = NULL;
  707.  
  708.  
  709.                     get (MUIlvRealms, MUIA_List_Entries, &selected);
  710.                     if (selected > 0)
  711.                     {
  712.                         get (MUIlvRealms, MUIA_List_Active, &selected);
  713.                         if (selected != MUIV_List_Active_Off)
  714.                         {
  715.                             DoMethod (MUIlvRealms, MUIM_List_GetEntry, selected, &realmname);
  716.                         }
  717.                     }
  718.                     
  719.                     DoMethod (MUIlvHosts, MUIM_List_Clear);
  720.                     BuildConfiguration ();
  721.                     ScanHosts (realmname);
  722.                     
  723.                     hosts = Hosts ();
  724.  
  725.                     for (host = hosts->lh_Head; host->ln_Succ; host = host->ln_Succ)
  726.                     {
  727.                         DoMethod (MUIlvHosts, MUIM_List_Insert, &(host->ln_Name), 1, MUIV_List_Insert_Sorted);
  728.                     }
  729.  
  730.                     if (!(IsListEmpty (hosts)))
  731.                     {
  732.                         set (MUIlvHosts, MUIA_List_Active, 0);
  733.                     }
  734.                 }
  735.                 break;
  736.  
  737.             case ID_Scan_Ping:
  738.                 {
  739.                     struct Node*    host;
  740.                     struct List*    hosts;
  741.                     char*           pingee;
  742.  
  743.                     get (MUIstPingHost, MUIA_String_Contents, &pingee);
  744.  
  745.                     DoMethod (MUIlvHosts, MUIM_List_Clear);
  746.                     BuildConfiguration ();
  747.  
  748.                     NP_Config |= NP_SingleHost;
  749.                     NP_ScanHost = pingee;
  750.  
  751.                     ScanPing ();
  752.  
  753.                     hosts = Hosts ();
  754.  
  755.                     for (host = hosts->lh_Head; host->ln_Succ; host = host->ln_Succ)
  756.                     {
  757.                         DoMethod (MUIlvHosts, MUIM_List_Insert, &(host->ln_Name), 1, MUIV_List_Insert_Sorted);
  758.                     }
  759.  
  760.                     if (!(IsListEmpty (hosts)))
  761.                     {
  762.                         set (MUIlvHosts, MUIA_List_Active, 0);
  763.                     }
  764.                 }
  765.                 break;
  766.  
  767.             case ID_Scan_All:
  768.                 {
  769.                     struct Node*    node;
  770.                     struct List*    list;
  771.  
  772.                     DoMethod (MUIlvHosts, MUIM_List_Clear);
  773.                     DoMethod (MUIlvRealms, MUIM_List_Clear);
  774.                     BuildConfiguration ();
  775.                     ScanAll ();
  776.  
  777.                     list = Realms ();
  778.  
  779.                     for (node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
  780.                     {
  781.                         DoMethod (MUIlvRealms, MUIM_List_Insert, &(node->ln_Name), 1, MUIV_List_Insert_Sorted);
  782.                     }
  783.  
  784.                     list = Hosts ();
  785.  
  786.                     for (node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
  787.                     {
  788.                         DoMethod (MUIlvHosts, MUIM_List_Insert, &(node->ln_Name), 1, MUIV_List_Insert_Sorted);
  789.                     }
  790.  
  791.                     if (!(IsListEmpty (list)))
  792.                     {
  793.                         set (MUIlvHosts, MUIA_List_Active, 0);
  794.                     }
  795.                 }
  796.                 break;
  797.  
  798.             case ID_LV_Hosts_Changed:
  799.                 {
  800.                     long selected;
  801.                     APTR hostname;
  802.  
  803.                     get (MUIlvHosts, MUIA_List_Active, &selected);
  804.                     DoMethod (MUIlvHosts, MUIM_List_GetEntry, selected, &hostname);
  805.  
  806.                     DecodeHost (getHost (hostname));
  807.                 }
  808.                 break;
  809.  
  810.             case ID_LV_Realms_Changed:
  811.                 break;
  812.  
  813.             default:
  814.                 break;
  815.         }
  816.  
  817.         if (running && signals) Wait(signals);
  818.     }
  819.  
  820.     set (MUIwinMain,  MUIA_Window_Open, FALSE);
  821.     set (MUIwinPrefs, MUIA_Window_Open, FALSE);
  822.     set (MUIwinScan,  MUIA_Window_Open, FALSE);
  823. }
  824.  
  825.  
  826.  
  827. BOOL OpenScanWindow (long max)
  828. {
  829.     set (MUIfgScanTime, MUIA_Gauge_Max,   max);
  830.     set (MUIbtStopScan, MUIA_Selected,    FALSE);
  831.     set (MUIbtStopScan, MUIA_Pressed,     FALSE);
  832.     set (MUIwinScan,    MUIA_Window_Open, TRUE);
  833.  
  834.     return (TRUE);
  835. }
  836.  
  837.  
  838.  
  839. void CloseScanWindow (void)
  840. {
  841.     set (MUIwinScan,  MUIA_Window_Open, FALSE);
  842. }
  843.  
  844.  
  845.  
  846. BOOL ShowScan (long current)
  847. {
  848.     long MuiSignals;
  849.     long Received;
  850.     long running = TRUE;
  851.     BOOL stopped = FALSE;
  852.     
  853.     struct MsgPort* time = TimePort ();
  854.  
  855.  
  856.     DoMethod (MUIApp, MUIM_Application_Input, &MuiSignals);
  857.  
  858.     set (MUIfgScanTime, MUIA_Gauge_Current, current);
  859.     
  860.     SendIO (TimeRequest ());
  861.  
  862.     while (running)
  863.     {
  864.         Received = Wait (MuiSignals | (1L << time->mp_SigBit));
  865.  
  866.         switch (DoMethod (MUIApp, MUIM_Application_Input, &MuiSignals))
  867.         {
  868.             case ID_Stop_Scan:
  869.                 running = FALSE;
  870.                 stopped = TRUE;
  871.                 break;
  872.  
  873.             default:
  874.                 break;
  875.         }
  876.  
  877.         if (Received & (1L << time->mp_SigBit))
  878.         {
  879.             running = FALSE;
  880.             while (GetMsg (time))
  881.                 ;
  882.         }
  883.     }
  884.     
  885.     return (stopped);
  886. }
  887.  
  888.  
  889.  
  890. static void HandleCheckBox (APTR CheckBox, APTR StringGadget)
  891. {
  892.     long selected;
  893.  
  894.     get (CheckBox, MUIA_Selected, &selected);
  895.     if (selected)
  896.     {
  897.         set (StringGadget, MUIA_Disabled, FALSE);
  898.     }
  899.     else
  900.     {
  901.         set (StringGadget, MUIA_Disabled, TRUE);
  902.     }
  903. }
  904.  
  905.  
  906.  
  907. static void BuildConfiguration (void)
  908. {
  909.     char*   foo;
  910.     long    selected;
  911.  
  912.  
  913.     //
  914.     //  First,  we need our numerical data
  915.     //
  916.     get (MUIstScanTime,     MUIA_String_Contents, &foo);
  917.     NP_ScanTime = atol (foo);
  918.  
  919.     get (MUIstScanPackets,  MUIA_String_Contents, &foo);
  920.     NP_ScanPackets = atol (foo);
  921.  
  922.     get (MUIstPingHost,     MUIA_String_Contents, &foo);
  923.     NP_ScanHost = foo;
  924.  
  925.  
  926.  
  927.     //
  928.     //  Now,  let's have a look at those buttons
  929.     //
  930.     NP_Config = NP_HostName;
  931.  
  932.     get (MUIcbIPAddr, MUIA_Selected, &selected);
  933.     if  (selected)
  934.     {
  935.         NP_Config |= NP_IPAddr;
  936.     }
  937.  
  938.  
  939.     get (MUIcbOwner, MUIA_Selected, &selected);
  940.     if  (selected)
  941.     {
  942.         NP_Config |= NP_Owner;
  943.     }
  944.  
  945.     get (MUIcbKickStart, MUIA_Selected, &selected);
  946.     if  (selected)
  947.     {
  948.         NP_Config |= NP_KickVersion;
  949.     }
  950.  
  951.  
  952.     get (MUIcbWorkBench, MUIA_Selected, &selected);
  953.     if  (selected)
  954.     {
  955.         NP_Config |= NP_WBVersion;
  956.     }
  957.  
  958.  
  959.     get (MUIcbNIPC, MUIA_Selected, &selected);
  960.     if  (selected)
  961.     {
  962.         NP_Config |= NP_NIPCVersion;
  963.     }
  964.  
  965.  
  966.     get (MUIcbFastMem, MUIA_Selected, &selected);
  967.     if  (selected)
  968.     {
  969.         NP_Config |= NP_MaxFastMem;
  970.         NP_Config |= NP_AvailFastMem;
  971.     }
  972.  
  973.  
  974.     get (MUIcbChipMem, MUIA_Selected, &selected);
  975.     if  (selected)
  976.     {
  977.         NP_Config |= NP_MaxChipMem;
  978.         NP_Config |= NP_AvailChipMem;
  979.     }
  980.  
  981.  
  982.     get (MUIcbProcessor, MUIA_Selected, &selected);
  983.     if  (selected)
  984.     {
  985.         NP_Config |= NP_ATTNFlags;
  986.     }
  987.  
  988.  
  989.     get (MUIcbChips, MUIA_Selected, &selected);
  990.     if  (selected)
  991.     {
  992.         NP_Config |= NP_ChipRevBits;
  993.     }
  994.  
  995.  
  996.     get (MUIcbServices, MUIA_Selected, &selected);
  997.     if  (selected)
  998.     {
  999.         NP_Config |= NP_Services;
  1000.     }
  1001.  
  1002.  
  1003.     get (MUIcbEntities, MUIA_Selected, &selected);
  1004.     if  (selected)
  1005.     {
  1006.         NP_Config |= NP_Entities;
  1007.     }
  1008.  
  1009.  
  1010.     get (MUIbt402Kludge, MUIA_Selected, &selected);
  1011.     if  (selected)
  1012.     {
  1013.         NP_Config |= NP_402_Kludge;
  1014.     }
  1015. }
  1016.  
  1017.  
  1018.  
  1019. static void DecodeHost (Host* foo)
  1020. {
  1021.     char string[255];
  1022.  
  1023.     //
  1024.     //  Name of owner
  1025.     //
  1026.     set (MUIstOwner, MUIA_Text_Contents, foo->Owner);
  1027.  
  1028.     //
  1029.     //  IP-address of primary network interface
  1030.     //
  1031.     if (NP_Config & NP_IPAddr)
  1032.         sprintf (string, "%ld.%ld.%ld.%ld", ((foo->IPAddr >> 24) & 0xff), ((foo->IPAddr >> 16) & 0xff), ((foo->IPAddr >> 8) & 0xff), (foo->IPAddr & 0xff));
  1033.     else
  1034.         string[0] = 0;
  1035.  
  1036.     set (MUIstIPAddr, MUIA_Text_Contents, &string);
  1037.  
  1038.     //
  1039.     //  Kickstart version
  1040.     //
  1041.     if (NP_Config & NP_KickVersion)
  1042.         sprintf (string, "%ld.%ld", ((foo->KickVersion >> 16) & 0xffff), (foo->KickVersion & 0xffff));
  1043.     else
  1044.         string[0] = 0;
  1045.  
  1046.     set (MUIstKickStart, MUIA_Text_Contents, &string);
  1047.  
  1048.     //
  1049.     //  Kickstart version
  1050.     //
  1051.     if (NP_Config & NP_WBVersion)
  1052.         sprintf (string, "%ld.%ld", ((foo->WBVersion >> 16) & 0xffff), (foo->WBVersion & 0xffff));
  1053.     else
  1054.         string[0] = 0;
  1055.  
  1056.     set (MUIstWorkBench, MUIA_Text_Contents, &string);
  1057.  
  1058.     //
  1059.     //  NIPC version
  1060.     //
  1061.     if (NP_Config & NP_NIPCVersion)
  1062.         sprintf (string, "%ld.%ld", ((foo->NIPCVersion >> 16) & 0xffff), (foo->NIPCVersion & 0xffff));
  1063.     else
  1064.         string[0] = 0;
  1065.  
  1066.     set (MUIstNIPC, MUIA_Text_Contents, &string);
  1067.  
  1068.     //
  1069.     //  Chip memory
  1070.     //
  1071.     if (NP_Config & NP_MaxChipMem)
  1072.         sprintf (string, "%ld K", (foo->MaxChipMem / 1024));
  1073.     else
  1074.         string[0] = 0;
  1075.  
  1076.     set (MUIstChipMem, MUIA_Text_Contents, &string);
  1077.  
  1078.     //
  1079.     //  Fast memory
  1080.     //
  1081.     if (NP_Config & NP_MaxFastMem)
  1082.         sprintf (string, "%ld K", (foo->MaxFastMem / 1024));
  1083.     else
  1084.         string[0] = 0;
  1085.  
  1086.     set (MUIstFastMem, MUIA_Text_Contents, &string);
  1087.  
  1088.     //
  1089.     //  Processor configuration
  1090.     //
  1091.     if (NP_Config & NP_ATTNFlags)
  1092.         sprintf (string, "%s", DecodeATTNFlags (foo->ATTNFlags));
  1093.     else
  1094.         string[0] = 0;
  1095.  
  1096.     set (MUIstProcessor, MUIA_Text_Contents, &string);
  1097.  
  1098.     //
  1099.     //  Chipset
  1100.     //
  1101.     if (NP_Config & NP_ChipRevBits)
  1102.         sprintf (string, "%s", DecodeChipRevBits (foo->ChipRevBits));
  1103.     else
  1104.         string[0] = 0;
  1105.  
  1106.     set (MUIstChips, MUIA_Text_Contents, &string);
  1107.  
  1108.     //
  1109.     //  Services
  1110.     //
  1111.     DoMethod (MUIlvServices, MUIM_List_Clear);
  1112.     if (NP_Config & NP_Services)
  1113.     {
  1114.         if (!(IsListEmpty (&(foo->Services))))
  1115.         {
  1116.             struct Node* work;
  1117.  
  1118.             for (work = foo->Services.lh_Head; work->ln_Succ; work = work->ln_Succ)
  1119.             {
  1120.                 Add (MUIlvServices, work->ln_Name);
  1121.             }
  1122.         }
  1123.     }
  1124.  
  1125.     //
  1126.     //  Entities
  1127.     //
  1128.     DoMethod (MUIlvEntities, MUIM_List_Clear);
  1129.     if (NP_Config & NP_Entities)
  1130.     {
  1131.         if (!(IsListEmpty (&(foo->Entities))))
  1132.         {
  1133.             struct Node* work;
  1134.  
  1135.             for (work = foo->Entities.lh_Head; work->ln_Succ; work = work->ln_Succ)
  1136.             {
  1137.                 Add (MUIlvEntities, work->ln_Name);
  1138.             }
  1139.         }
  1140.     }
  1141. }
  1142.  
  1143.  
  1144.  
  1145. static void Add (APTR list, char* string)
  1146. {
  1147.     DoMethod (list, MUIM_List_Insert, &string, 1, MUIV_List_Insert_Sorted);
  1148. }
  1149.